﻿#define _CRT_SECURE_NO_WARNINGS 1
// 动态规划

//class Solution {
//public:
//    int MinData(vector<int>& prices, int left, int right)
//    {
//        int mindata = prices[left];
//        for (int i = left; i <= right; i++)
//        {
//            mindata = min(mindata, prices[i]);
//        }
//        return mindata;
//    }
//    int maxProfit(vector<int>& prices) {
//        int len = prices.size();
//        vector<int> dp(len);
//        if (len == 1) return 0;
//        if (len == 2) return prices[0] > prices[1] ? 0 : prices[1] - prices[0];
//        dp[0] = 0;
//        dp[1] = prices[0] > prices[1] ? 0 : prices[1] - prices[0];
//        dp[2] = min(prices[0], prices[1]) > prices[2] ? 0 : prices[2] - min(prices[0], prices[1]);
//        cout << dp[0] << ' ' << dp[1] << ' ' << dp[2] << ' ';
//        int maxdata = 0;
//        int n = 3;
//        for (int i = 3; i < len; i++)
//        {
//            if (maxdata < dp[i - 3])
//            {
//                maxdata = dp[i - 3];
//                n = i - 3;
//            }
//            dp[i] = max(maxdata - MinData(prices, n, i - 1) + prices[i], 0);
//            cout << dp[i] << ' ';
//        }
//        sort(dp.begin(), dp.end(), greater<int>());
//        return dp[0];
//    }
//};

//class Solution {
//public:
//    int maxProfit(vector<int>& prices) {
//        int n = prices.size();
//        int dp[n][2];
//        dp[0][0] = 0, dp[0][1] = -prices[0];
//        for (int i = 1; i < n; ++i) {
//            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
//            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
//        }
//        for (int i = 0; i < n; i++)
//        {
//            cout << dp[i][0] << ' ';
//        }
//        cout << endl;
//        for (int i = 0; i < n; i++)
//        {
//            cout << dp[i][1] << ' ';
//        }
//        cout << endl;
//        return dp[n - 1][0];
//    }
//};

//class Solution {
//public:
//    int maxProfit(vector<int>& prices)
//    {
//        int m = prices.size();
//        vector<vector<int>> dp(3, vector<int>(m));
//        dp[0][0] = -prices[0];//第i天买入的最大利润
//        dp[1][0] = 0;//第i天卖出的最大利润
//        dp[2][0] = 0;//第i天处于冷静期的最大利润
//        for (int j = 1; j < m; j++)
//        {
//            dp[0][j] = max(dp[0][j - 1], dp[2][j - 1] - prices[j]);
//            dp[1][j] = max(dp[1][j - 1], dp[0][j - 1] + prices[j]);
//            dp[2][j] = dp[1][j - 1];
//        }
//        return dp[1][m - 1];
//    }
//};

//class Solution {
//public:
//    int maxProfit(vector<int>& prices, int fee) {
//        int n = prices.size();
//        vector<vector<int>> dp(n, vector<int>(2));
//        dp[0][0] = -prices[0], dp[0][1] = 0;
//
//        for (int i = 1; i < n; i++)
//        {
//            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
//            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
//        }
//        return dp[n - 1][1];
//    }
//};

//class Solution {
//public:
//    int maxProfit(vector<int>& prices)
//    {
//        int n = prices.size();
//        int count = 0;
//        vector<vector<int>> dp(n, vector<int>(2));
//        vector<int> f(n);
//        dp[0][0] = -prices[0], dp[0][1] = 0;
//        for (int i = 1; i < n; i++)
//        {
//            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
//            if (dp[i - 1][1] < dp[i - 1][0] + prices[i])
//            {
//                dp[i][1] = dp[i - 1][0] + prices[i];
//                count++;
//                if (count == 2)
//                {
//                    f[i] = dp[i][1];
//                    count = 0;
//                }
//            }
//            else
//            {
//                dp[i][1] = dp[i - 1][1];
//            }
//        }
//        sort(f.begin(), f.end(), greater<int>());
//        return f[0];
//    }
//};

//class Solution {
//public:
//    int maxProfit(vector<int>& prices) {
//        int n = prices.size();
//        int buy1 = -prices[0], sell1 = 0;
//        int buy2 = -prices[0], sell2 = 0;
//        for (int i = 1; i < n; ++i) {
//            buy1 = max(buy1, -prices[i]);
//            sell1 = max(sell1, buy1 + prices[i]);
//            buy2 = max(buy2, sell1 - prices[i]);
//            sell2 = max(sell2, buy2 + prices[i]);
//        }
//        return sell2;
//    }
//};

//class Solution {
//public:
//    int maxProfit(int k, vector<int>& prices) {
//        int n = prices.size();
//        vector<vector<int>> buy(n, vector<int>(k + 1, -prices[0]));
//        vector<vector<int>> sell(n, vector<int>(k + 1, 0));
//        for (int i = 1; i < n; i++)
//        {
//            for (int j = 0; j <= k; j++)
//            {
//                buy[i][j] = max(buy[i - 1][j], sell[i - 1][j] - prices[i]);
//                if (j != 0)
//                {
//                    sell[i][j] = max(sell[i - 1][j], buy[i - 1][j - 1] + prices[i]);
//                }
//
//            }
//        }
//
//        int value = 0;
//        for (int i = 1; i < n; i++)
//        {
//            value = max(sell[i][k], value);
//        }
//        return value;
//    }
//};

//class Solution {
//public:
//    int maxSubArray(vector<int>& nums) {
//        int n = nums.size();
//        vector<int> dp(n);
//        dp[0] = nums[0] > 0 ? nums[0] : 0;
//        for (int i = 1; i < n; i++)
//        {
//            dp[i] = max(dp[i - 1] + nums[i], 0);
//        }
//        sort(dp.begin(), dp.end(), greater<int>());
//        if (dp[0] == 0)
//        {
//            sort(nums.begin(), nums.end(), greater<int>());
//            return nums[0];
//        }
//        return dp[0];
//    }
//};

//class Solution {
//public:
//    int MaxNums(int left, int right, vector<int>& arry)
//    {
//        int ret = arry[left];
//        int maxdata = ret;
//        for (int i = left + 1; i <= right; i++)
//        {
//            ret = max(arry[i], arry[i] + ret);
//            maxdata = max(maxdata, ret);
//        }
//        return maxdata;
//    }
//    int maxSubarraySumCircular(vector<int>& nums) {
//        int n = nums.size();
//        vector<int> arry(2 * n);
//        vector<int> dp(2 * n);
//
//        for (int i = 0; i < 2 * n; i++)
//        {
//            arry[i] = nums[i % n];
//        }
//        dp[0] = nums[0];
//
//        for (int i = 1; i < n; i++)
//        {
//            dp[i] = max(dp[i - 1] + arry[i], arry[i]);
//        }
//
//        for (int i = n; i < 2 * n; i++)
//        {
//            int x = i % n + 1;
//            dp[i] = MaxNums(x, i, arry);
//        }
//        sort(dp.begin(), dp.end());
//        return dp[2 * n - 1];
//    }
//};

//class Solution {
//public:
//    int maxSubarraySumCircular(vector<int>& nums) {
//        int n = nums.size();
//        vector<int> f(n);
//        vector<int> g(n);
//
//        int maxdata = nums[0], mindata = nums[0];
//        int sum = nums[0];
//        f[0] = nums[0], g[0] = nums[0];
//
//        for (int i = 1; i < n; i++)
//        {
//            f[i] = max(nums[i], f[i - 1] + nums[i]);
//            maxdata = max(f[i], maxdata);
//            g[i] = min(nums[i], g[i - 1] + nums[i]);
//            mindata = min(g[i], mindata);
//            sum += nums[i];
//        }
//
//        if (sum - mindata == 0) return maxdata;
//        return max(maxdata, sum - mindata);
//    }
//};

//class Solution {
//public:
//    int maxProduct(vector<int>& nums) {
//        int n = nums.size();
//        int maxdata = nums[0];
//        vector<int> f(n);
//        vector<int> g(n);
//        f[0] = nums[0], g[0] = nums[0];
//
//        for (int i = 1; i < n; i++)
//        {
//            f[i] = max(nums[i], max(f[i - 1] * nums[i], g[i - 1] * nums[i]));
//            g[i] = min(nums[i], min(f[i - 1] * nums[i], g[i - 1] * nums[i]));
//            maxdata = max(f[i], maxdata);
//        }
//        return maxdata;
//    }
//};


#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <unordered_map>
#include <algorithm>
using namespace std;

int main()
{
	int a = 0xffffffff;
	cout << a << endl;
	cout << INT_MAX << endl;
	cout << INT_MIN << endl;
	return 0;
}